/**
 * 工具类
 */


/**
 * 格式化日期格式 (用于兼容ios Date对象)
 */
export const formatDate = (time) => {
   // 将xxxx-xx-xx的时间格式，转换为 xxxx/xx/xx的格式 
   return time.replace(/\-/g, "/");
}

/**
 * 对象转URL
 * @param {object} obj
 */
export const urlEncode = (obj = {}) => {
   const result = []
   for (const key in obj) {
      const item = obj[key]
      if (!item) {
         continue
      }
      if (isArray(item)) {
         item.forEach(val => {
            result.push(key + '=' + val)
         })
      } else {
         result.push(key + '=' + item)
      }
   }
   return result.join('&')
}

/**
 * 遍历对象
 */
export const objForEach = (obj, callback) => {
   Object.keys(obj).forEach((key) => {
      callback(obj[key], key)
   });
}

/**
 * 是否在数组内
 */
export const inArray = (search, array) => {
   for (var i in array) {
      if (array[i] == search) return true
   }
   return false
}

/**
 * 对Date的扩展，将 Date 转化为指定格式的String
 * 月(Y)、月(m)、日(d)、小时(H)、分(M)、秒(S) 可以用 1-2 个占位符，
 * 例子：
 * dateFormat('YYYY-mm-dd HH:MM:SS', new Date()) ==> 2020-01-01 08:00:00
 */
export const dateFormat = (fmt, date) => {
   const opt = {
      "Y+": date.getFullYear().toString(), // 年
      "m+": (date.getMonth() + 1).toString(), // 月
      "d+": date.getDate().toString(), // 日
      "H+": date.getHours().toString(), // 时
      "M+": date.getMinutes().toString(), // 分
      "S+": date.getSeconds().toString() // 秒
      // 有其他格式化字符需求可以继续添加，必须转化成字符串
   };
   let ret
   for (let k in opt) {
      ret = new RegExp("(" + k + ")").exec(fmt)
      if (ret) {
         fmt = fmt.replace(ret[1], (ret[1].length == 1) ? (opt[k]) : (opt[k].padStart(ret[1].length, "0")))
      };
   };
   return fmt
}

/**
 * 判断是否为空对象
 * @param {*} object 源对象
 */
export const isEmptyObject = (object) => {
   return Object.keys(object).length === 0
}

/**
 * 判断是否为非空对象
 * @param {*} object 源对象
 */
export const isNotEmptyObject = (object) => {
   return Object.keys(object).length !== 0
}

/**
 * 判断是否为对象
 * @param {*} object
 */
export const isObject = (object) => {
   return Object.prototype.toString.call(object) === '[object Object]'
}

/**
 * 判断是否为数组
 * @param {*} array
 */
export const isArray = (array) => {
   return Object.prototype.toString.call(array) === '[object Array]'
}

/**
 * 判断是否为空
 * @param {*} object 源对象
 */
export const isEmpty = (value) => {
   if (isArray(value)) {
      return value.length === 0
   }
   if (isObject(value)) {
      return isEmptyObject(value)
   }
   return !value
}

/**
 * 对象深拷贝
 * @param {*} obj 源对象
 */
export const cloneObj = (obj) => {
   let newObj = obj.constructor === Array ? [] : {};
   if (typeof obj !== 'object') {
      return;
   }
   for (let i in obj) {
      newObj[i] = typeof obj[i] === 'object' ? cloneObj(obj[i]) : obj[i];
   }
   return newObj
}

// 节流函数
// 思路： 第一次先设定一个变量true，
// 第二次执行这个函数时，会判断变量是否true，
// 是则返回。当第一次的定时器执行完函数最后会设定变量为flase。
// 那么下次判断变量时则为flase，函数会依次运行。
export function throttle(fn, delay = 100) {
   // 首先设定一个变量，在没有执行我们的定时器时为null
   var timer = null
   return function() {
      // 当我们发现这个定时器存在时，则表示定时器已经在运行中，需要返回
      if (timer) return
      timer = setTimeout(() => {
         fn.apply(this, arguments)
         timer = null
      }, delay)
   }
}

// 防抖函数
// 首次运行时把定时器赋值给一个变量， 第二次执行时，
// 如果间隔没超过定时器设定的时间则会清除掉定时器，
// 重新设定定时器， 依次反复， 当我们停止下来时，
// 没有执行清除定时器， 超过一定时间后触发回调函数。
// 参考文档：https://segmentfault.com/q/1010000021145192
export function debounce(fn, delay) {
   let timer
   return function() {
      const that = this
      const _args = arguments // 存一下传入的参数
      if (timer) {
         clearTimeout(timer)
      }
      timer = setTimeout(function() {
         fn.apply(that, _args)
      }, delay)
   }
}


/**
 * 数组交集
 * @param {Array} 数组1
 * @param {Array} 数组2
 * @return {Array}
 */
export const arrayIntersect = (array1, array2) => {
   return array1.filter(val => array2.indexOf(val) > -1)
}

/**
 * 隐藏字符串
 * @param string str 字符串
 * @param int frontLen 前面需要保留几位
 * @param int endLen 后面需要保留几位
 */
export const hiddenString = (str, frontLen, endLen) => {
   var len = str.length - frontLen - endLen;
   var xing = '';
   for (var i = 0; i < len; i++) {
      xing += '*';
   }
   return str.substring(0, frontLen) + xing + str.substring(str.length - endLen);
}

/**
 * 判断小数位数并保留
 * @param string num 参数
 */
export const decimalCount = (num) => {
   if(num === '' || num === undefined || num === 'undefined' || isNaN(num)) return;
   if(Number(num) == 0) {
      return '0.00';
   }
   //console.log(Number(num))
   if(!(num.toString().indexOf('.') != -1)) {
      return Number(num);
   }
   var len = num.toString().split('.')[1].length;
   if(len > 4) {
      return Number(num).toFixed(4);
   }
   return Number(num);
}

/**
 * 字符串省略...
 * @param string val 字符串
 * @param int lengths 前面需要保留几位
 */
export const cutString = (val,lengths) => {
  var length_val = val.length + '';
  if (length_val == 0 || val == undefined) {
    return;
  }
  if (length_val > lengths) {
    return val.substring(0, lengths) + "...";
  } else {
    return val;
  }
}

/**
 * 处理富文本里的图片宽度自适应
 * 1.去掉img标签里的style、width、height属性
 * 2.img标签添加style属性：max-width:100%;height:auto
 * 3.修改所有style里的width属性为max-width:100%
 * 4.去掉<br/>标签
 * @param html
 * @returns {void|string|*}
 */

export function formatRichText(html){
  let newContent= html.replace(/<img[^>]*>/gi,function(match,capture){
    match = match.replace(/style="[^"]+"/gi, '').replace(/style='[^']+'/gi, '');
    match = match.replace(/width="[^"]+"/gi, '').replace(/width='[^']+'/gi, '');
    match = match.replace(/height="[^"]+"/gi, '').replace(/height='[^']+'/gi, '');
    return match;
  });
  newContent = newContent.replace(/style="[^"]+"/gi,function(match,capture){
    match = match.replace(/width:[^;]+;/gi, 'max-width:100%;').replace(/width:[^;]+;/gi, 'max-width:100%;');
    return match;
  });
  newContent = newContent.replace(/<br[^>]*\/>/gi, '');
  newContent = newContent.replace(/\<img/gi, '<img style="max-width:100%;height:auto;display:block;margin-top:0;margin-bottom:0;"');
  return newContent;
}
// 回显数据名
export function selectLabel(datas,value,dictValue='dictValue',dictLabel='dictLabel') {
	const actions = [];
	Object.keys(datas).some((key) => {
		if (datas[key][dictValue] === ('' + value)) {
			actions.push(datas[key][dictLabel]);
			return true;
		}
	})
	return actions.join('');
}